#include "smart_rga2.hpp"
#include <cstring>
#include <cstdlib>

// int SmartRga::rga_init(int src_width, int src_height, RgaSURF_FORMAT src_format, int dst_width, int dst_height, RgaSURF_FORMAT dst_format)
// {
//     // rga_deinit();

//     memset(&m_src_rect, 0, sizeof(m_src_rect));
//     memset(&m_dst_rect, 0, sizeof(m_dst_rect));
//     memset(&m_src, 0, sizeof(m_src));
//     memset(&m_dst, 0, sizeof(m_dst));

//     // m_src_width = src_width;
//     // m_src_height = src_height;
//     // m_src_format = src_format;

//     // m_dst_width = dst_width;
//     // m_dst_height = dst_height;
//     // m_dst_format = dst_format;

//     return 0;
// }

// int SmartRga::rga_deinit()
// {
//     return 0;
// }

// int SmartRga::rga_proc(rga_mode_t mode, std::vector<uint8_t>& src_buf, std::vector<uint8_t>& dst_buf)
// {
//     // m_src_handle = importbuffer_virtualaddr(src_buf.data(), m_src_width, m_src_height, m_src_format);
//     // if (m_src_handle <= 0) {
//     //     LOG_ERROR("Failed to import virtualaddr for src channel!\n");
//     //     exit(EXIT_FAILURE);
//     // }

//     // m_dst_handle = importbuffer_virtualaddr(dst_buf.data(), m_dst_width, m_dst_height, m_dst_format);
//     // if (m_dst_handle <= 0) {
//     //     LOG_ERROR("Failed to import virtualaddr for dst channel!\n");
//     //     exit(EXIT_FAILURE);
//     // }

//     // m_src = wrapbuffer_handle(m_src_handle, m_src_width, m_src_height, m_src_format);
//     // m_dst = wrapbuffer_handle(m_dst_handle, m_dst_width, m_dst_height, m_dst_format);
//     // if(m_src.width == 0 || m_dst.width == 0) {
//     //     LOG_ERROR("%s, %s", __FUNCTION__, imStrError());
//     //     exit(EXIT_FAILURE);
//     // }

//     switch (mode) {
//     case MODE_QUERYSTRING:
//         break;

//     case MODE_COPY:
//         break;

//     case MODE_RESIZE:
//         break;

//     case MODE_CROP:
//         break;

//     case MODE_ROTATE:
//         break;

//     case MODE_FLIP:
//         break;

//     case MODE_TRANSLATE:
//         break;

//     case MODE_BLEND:
//         break;

//     case MODE_CVTCOLOR:
//         break;

//     case MODE_FILL:
//         break;

//     case MODE_WHILE:
//         break;
    
//     default:
//         break;
//     }

//     // // release rga buffer handle
//     // releasebuffer_handle(m_src_handle);
//     // releasebuffer_handle(m_dst_handle);
//     return 0;
// }

int SmartRga::rga_query_string()
{
    LOG_DEBUG("\n%s\n", querystring(RGA_ALL));
    return 0;
}

int SmartRga::rga_copy()
{
    IM_STATUS STATUS;
    STATUS = imcopy(m_src, m_dst);
    if (STATUS != IM_STATUS_SUCCESS) {
        printf("copying error, %s\n", imStrError(STATUS));
    }
    return STATUS;
}

int SmartRga::rga_resize(std::vector<uint8_t>& src_buf, rga_cfg_t* src_cfg, std::vector<uint8_t>& dst_buf, rga_cfg_t* dst_cfg)
{
    int ret;
    IM_STATUS STATUS;

    m_src_handle = importbuffer_virtualaddr(src_buf.data(), src_cfg->width, src_cfg->height, src_cfg->format);
    if (m_src_handle <= 0) {
        LOG_ERROR("Failed to import virtualaddr for src channel!\n");
        goto FAILED_RESIZE;
    }

    dst_buf.reserve(dst_cfg->width * dst_cfg->height * get_bpp_from_format(dst_cfg->format));
    m_dst_handle = importbuffer_virtualaddr(dst_buf.data(), dst_cfg->width, dst_cfg->height, dst_cfg->format);
    if (m_dst_handle <= 0) {
        LOG_ERROR("Failed to import virtualaddr for dst channel!\n");
        goto FAILED_RESIZE;
    }

    m_src = wrapbuffer_handle(m_src_handle, src_cfg->width, src_cfg->height, src_cfg->format);
    m_dst = wrapbuffer_handle(m_dst_handle, dst_cfg->width, dst_cfg->height, dst_cfg->format);
    if(m_src.width == 0 || m_dst.width == 0) {
        LOG_ERROR("%s, %s", __FUNCTION__, imStrError());
        goto FAILED_RESIZE;
    }

    ret = imcheck(m_src, m_dst, m_src_rect, m_dst_rect);
    if (IM_STATUS_NOERROR != ret) {
        LOG_ERROR("%d, check error! %s\n", __LINE__, imStrError((IM_STATUS)ret));
        goto FAILED_RESIZE;
    }

    STATUS = imresize(m_src, m_dst);
    if (STATUS != IM_STATUS_NOERROR) {
        LOG_ERROR("%s.", imStrError(STATUS));
        goto FAILED_RESIZE;
    }

    releasebuffer_handle(m_src_handle);
    releasebuffer_handle(m_dst_handle);
    return 0;

FAILED_RESIZE:
    // release rga buffer handle
    releasebuffer_handle(m_src_handle);
    releasebuffer_handle(m_dst_handle);
    return -1;
}

int SmartRga::rga_crop()
{
    return 0;
}

int SmartRga::rga_rotate()
{
    return 0;
}

int SmartRga::rga_flip()
{
    return 0;
}

int SmartRga::rga_translate()
{
    return 0;
}

int SmartRga::rga_blend()
{
    return 0;
}

int SmartRga::rga_cvtcolor()
{
    return 0;
}

int SmartRga::rga_fill()
{
    return 0;
}

int SmartRga::rga_while()
{
    return 0;
}
